The Original Shareware 1.1

home *** CD-ROM | disk | FTP | other *** search

/ The Original Shareware 1.1 / The Original Shareware (WeMake CDs)(Volume 1.1)(CDs, Inc)(1993).iso / 6 / a86v319c.zip / A14.DOC < prev next >

Wrap

Text File | 1988-05-20 | 30KB | 681 lines

CHAPTER 14 DESCRIPTIONS OF A86 ERROR MESSAGES ~01 Unknown Mnemonic~ Most assembly-language lines start with a built-in instruction mnemonic such as MOV or ADD. The only circumstances in which a line can start with non-built-in symbol are if the symbol is a macro name or INT equate, or if the symbol is now being defined, as indicated by a limited set of following symbols: a colon, EQU, DB, DW, etc. This line started with a non-built-in symbol which did not fall into any of the above categories. You might have misspelled an instruction mnemonic, or misspelled the following word. ~02 Jump > 128~ The destination operand of a conditional jump must be a label within 128 bytes of the end of the instruction. (Precisely, from -128 to +127 from the next instruction, which is from -126 to +129 from the start of the conditional jump.) This error is reported in three possible places: 1. At the conditional jump. The operand is more than 126 bytes before the jump, or the operand is not a label (e.g. you tried an indirect conditional jump through a variable, which isn't allowed) 2. At a label definition. In this case, you use your editor to search backwards for references to the label. One or more of the earliest conditional jumps found are too far away. 3. At a RET, RETF, or IRET instruction. You use your editor to search backwards for that flavor of RET used as the operand to a conditional jump (the A86 conditional return feature). The earliest such jumps not satisfied by a previous RET are too far away. You usually correct this error by rearranging your code, or (better) by breaking intervening code off into subroutines. If desperate, you can replace "Jcond" with "IF cond JMP". ~03 [BX+BP] And [SI+DI] Not Allowed~ The 86 instruction set does not support the combinations of indexing registers indicated in the error message. In previous versions of A86, this error was reported in other illegal operand combinations; I've attempted to change other cases to error 14. If you ever find otherwise, let me know. ~04 Bad Character In Number~ All numbers, and only numbers, start with a decimal digit. (It's illegal to have a symbol begin with a digit; e.g. 01MYVAR .) You have coded something that starts with a decimal digit but does not have the correct format for a numeric constant. See Chapter 8 for detailed descriptions of the formats of both integer and floating constants. 14-2 ~05 Operands Not Allowed~ When this error is reported it usually means that you have provided something more than just the mnemonic for an instruction that does not have any operands: e.g., PUSHF, STOSB, STC, FLDPI, CLTS. It's also called in other contexts when the assembler expects nothing more on the line; e.g., NAME with more than just a single name following, or something following the word ENDS. ~06 Symbol Required~ This is reported in numerous situations where A86 requires some sort of symbol: either a built-in assembler mnemonic, or a symbol you define. (It's possible that a number or some punctuation marks are legal in the context, and that they have already been checked for.) Instead of a symbol, a punctuation mark or out-of-context number was seen. The contexts in which this error can occur include: * the start of a line (characters hex 3C or greater) * after the following at the start of a line: a symbol you define, #, #IF, IF, CODE, or DATA * where operands to the following directives are expected: NAME, PUBLIC, EXTRN, GROUP, SEGMENT * after ">" denoting a local-label forward reference ~07 Local Symbol Required~ This is reported when something other than a generic local label (letter followed by one or more digits) follows a ">" mark, which denotes a local-label forward reference. If you meant "greater than" you use the GT operator instead. ~08 Too Many Operands~ This is reported for instructions and directives requiring a limited number of operands, for which the limit is exceeded. Since operands are separated by commas, you have too many commas-- possibly an extra comma between the mnemonic and first operand, or at the end of the operands. ~09 Constant Required~ This is reported for instructions and directives (ENTER, RET, RADIX, etc.) requiring operands that are an immediate constant number; and for expression operators (*, /, SHL, OR, NOT, BY, etc.) whose operands must be constant. In some cases a limited number of forms other than constants are acceptable, but the assembler has already checked for and not found those possibilities. ~10 More Operands Required~ 14-3 This is reported for instructions requiring two operands, for which you have provided no operands or only one operand. You might have left out the comma separating the operands. ~11 Constant/Label Not Allowed~ This is reported when you have given a constant number in a place where it isn't allowed-- usually as a destination operand to an instruction, such as the first operand to a MOV or ADD. If you meant the operand to be the memory location with the constant offset, you must convert the type by enclosing the operand in brackets [ ] or appending a size- specifier (B, W, D, Q, or T) to the number. ~12 Segment Register Not Allowed~ This is reported when you have used a segment register in an instruction where it isn't allowed. The only instructions allowing segment registers as operands are MOV, PUSH, and POP. You can't, for example, ADD into a segment register. If you want to do anything with a segment register value, you have to MOV it into a general register, perform the operation, then MOV the result back to the segment register. ~13 Byte/Word Combination Not Allowed~ This is reported in a two-byte instruction in which one operand is byte-sized and the other word-sized; or in an instruction with a byte-sized destination and an immediate source whose value is not byte-sized (high byte not 0 or 0FF). If one of the operands is a memory variable of the wrong size, you either change the declaration of the variable (DB to DW or vice versa) or override the size of the variable in this instruction only, by appending a " B" or " W" to the memory operand. ~14 Bad Operand Combination~ This is reported when you attempt to add or combine terms in an operand expression that do not allow combination. An example of this would be DT 3.7+BX. Only constants can be added to floating point numbers. This is also reported when you have two operands that are mismatched in size, and the mismatch is something other than Byte vs. Word. Example: MOV AL,D[0100]. ~15 Bad Subtraction Operands~ This is reported when you attempt to subtract terms in an operand expression that do not allow subtraction, or if the right-hand side to a subtraction is missing. If the right- hand side to a subtraction is a non-forward-referenced constant, then the left side can be almost anything. Otherwise, the operands must match; e.g., labels from relocatable segments must be in the same segment (in which case the answer is an absolute constant; namely, the size of the block of memory between the two labels). 14-4 ~16 Definition Conflicts With Forward Reference~ This error occurs when the assembler has previously guessed the type of a forward-referenced symbol in order to determine what kind of instruction to generate, and the guess turned out to be wrong. The error is reported at the time the symbol is defined. For example, when A86 sees MOV AX,FOO, it will assume FOO is an immediate value. This error is reported if FOO turns out to be a word variable: FOO DW 0. You need to search backwards from the error message, to references of FOO, and specify the type you intend to be used: MOV AX,FOO W. If you really did intend to load the offset of FOO and not the memory contents, you can code MOV AX,OFFSET FOO to make the error message go away. ~17 Divide Overflow~ This is reported when the right-hand side to a division or MOD operation is zero, or when the result of a division by a large (>64K) number is still large. ~18 Same Type Required~ This is reported when the two operands to a relational operator (EQ, NE, GT, GE, LT, or LE) are of different types. The operands to a relational operator ought to be both absolute integer constants, or labels in the same segment. ~19 CS Destination Not Allowed~ This is reported if you attempt to specify CS as the destination (first) operand to MOV, or as an operand to POP. The only acceptable way to load CS on the 8086 is via a far JMP, CALL, RETF, or IRET instruction. The MOV and POP forms don't make much sense, so they were outlawed by Intel. ~20 Left Operand Not Allowed~ This is reported if you have a left-hand side to an expression operator that expects only a single operand to its right. Those operators are BIT, NOT, OFFSET, TYPE, LOW, HIGH, SHORT, LONG, and INT. (The mnemonic INT is considered an operator e.g., in MSDOS EQU INT 33.) For example, you would get this error for the expression 1 NOT 2. ~21 Bad Single Operand~ This is reported if the operand is inappropriate for an instruction INC, DEC, PUSH, POP, NOT, NEG, MUL, IMUL, DIV, or IDIV, that takes a single operand. You should look up the instruction in the chart in Chapter 6, to determine the proper operand forms allowed. ~22 Bad DUP Usage~ 14-5 This is reported when a DUP construct occurs out of context (e.g. in an instruction operand instead of a data initialization); when the total number of bytes generated would push the output pointer beyond 64K; or when there is improper syntax for a DUP. See Chapter 9 for the description of correct DUP usage. ~23 Number Too Large~ This is reported when a numeric constant is too large for the assembler to store in its operand buffers-- the limit for integers is 2**80-1 = 1208925819614629174706175 decimal. The error is also given when the exponent part of a floating point constant is greater than 65535 in magnitude. ~24 SEGMENT or ENDS Required~ This is reported if a line beginning with one of the two A86 keywords CODE or DATA does not continue with one of the keywords SEGMENT or ENDS. If you meant CODE or DATA to be a symbol you define, you have to change the name to something else, like _CODE or _DATA. ~25 Bad CALL/JMP Operand~ This is reported if the operand to a call or jump instruction cannot be taken as a jump destination. This occurs if the operand is missing, or if it has a size inappropriate for address pointers: byte, quadword, or ten-byte. The error also occurs if the operand is a constant number, and you are assembling to an OBJ format. In OBJ format anything jumped to within a segment must be specified as a label within some segment. ~26 Memory Doubleword Required~ This is reported if the second operand to an LDS, LES, or BOUND instruction is of the wrong type. The operand should be a doubleword memory quantity; but A86 will accept a word memory variable or a memory variable of unspecified size. ~27 Bad IN/OUT Operand~ This is reported when the operands to IN or OUT do not have the correct form. See Chapter 6 for the limited set of forms for these instructions. One of the operands must be AL or AX; the other must be DX or a constant between 0 and 255. ~28 :type Required~ This is reported when a symbol given in an EXTRN list is not followed by a colon followed by one of the type names B, W, D, Q, T, F, NEAR, or ABS. The more verbose synonyms BYTE, WORD, DWORD, QWORD, and TBYTE are also acceptable. ~29 Bad Rotate/Shift Operand~ 14-6 This is reported when the count (second) operand to a rotate or shift instruction is not appropriate: it should be either the name CL or a constant less than 32. The instructions requiring this are ROL, ROR, RCL, RCR, SHL, SHR, SAL, SAR, and the NEC-specific instructions SETBIT, TESTBIT, CLRBIT, and NOTBIT. ~30 Byte-Sized Constant Required~ This is reported in contexts where only a byte-sized absolute constant is acceptable. Those contexts are: the operand to a BIT or INT operator in an expression; the required operand to an INT or CALL80 instruction; the optional operand to an AAM or AAD instruction. ~31 Instruction In Data Segment Not Allowed~ There are only a limited number of directives allowed with a STRUC or a DATA segment. This error is reported when any instructions or disallowed directives are seen in one of these restricted environments. You have possibly neglected to provide an ENDS directive, returning you to normal assembly. In a STRUC, the only directives allowed are DB, DW, DD, DQ, DT, another STRUC, ENDS, EQU, SEGMENT, GROUP, MACRO, LABEL, EVEN, and ORG. The DATA segment allows the same directives, plus PROC, ENDP, DATA, and CODE. ~32 Bad String~ This is reported when you start a quoted string, and do not provide the closing quote in the same line. You might have left it out; or you might not have intended to code a string at all, and accidentally inserted a single- or double-quote mark in your line. Or you might have intended a string containing an end-of-line, which isn't allowed. You must instead close the string and code hex bytes 0D,0A to represent an end-of-line. ~33 Bad Data Operand~ This is reported if an inappropriate operand is seen in a data initialization (DB, DW, DD, DQ, or DT) directive. Examples of this are indexed quantities such as [BX], non-byte quantities in a DB, or floating point constants in a DB or DW. ~34 Index Brackets Required~ This is reported if the name of a register is given in an addition/combination operation, but the register is not enclosed in square brackets. The only registers that may be added are those presented as indexing registers. For example, don't code BX+2, code [BX+2]. ~35 Bad Character~ 14-7 This is reported when a punctuation mark or other non-standard character is seen where it is not expected. The characters causing this error at the beginning of a line are digits, and the marks / - , + * ( ) & " ! -- other illegal marks at the start of a line cause error 6, Symbol Required. The characters causing this error elsewhere (i.e. within operands) are all characters except letters, digits, and the marks [ ] + - ' " > ( ) * . / : ~36 String > 2 Not Allowed~ This is reported when a string with 3 or more characters is seen outside of the places where such a string is allowed (in a DB directive, macro operand, or relocatable SEGMENT directive). One- and two-character strings are treated as simple numeric constants; but longer strings require special handling and are allowed only in the places mentioned. ~37 Misplaced Built-In Symbol~ The symbol just before this error message is an A86 built-in symbol, that is in a place where it doesn't belong. Examples of this are: mnemonics such as MOV occurring in operands; and symbols that aren't mnemonics such as LT occurring at the start of the line. If you thought you could define the symbol to the left of this message for your own use, you were wrong. You need to change the symbol to something else: TEST to _TEST, for example. If you'd like to know the built-in meaning of the symbol, you can look it up in Chapter 16. ~38 Segment Combination Not Allowed~ This is reported when you attempt to add or combine a segment or group name with another quantity. A86 currently doesn't allow this. ~39 Bad Index Register~ This is reported when you attempt to use a register other than SI, DI, BX, or BP for indexing. Those are the only registers that the 86 architecture allows you to place inside brackets, to address memory. ~40 Conflicting Multiple Definition Not Allowed~ This is reported when you define a symbol in two places in your program, and the definitions aren't the same. Most often you have simply forgotten you already had a symbol somewhere of the same name, and you need to change the name of one of the two symbols you've defined. A86 allows the re-use of a symbol if it is a generic local label (a letter followed by one or more digits), or if is defined with = instead of EQU. A86 also allows the redefinition of a symbol if it has exactly the same value (e.g. ESC EQU 01B in two places in your program). See the section "Duplicate Definitions" in Chapter 9 for a detailed discussion of this feature. ~41 ENDS Has No Segment~ 14-8 This error occurs when A86 is assembling to an OBJ file, and it sees an ENDS at the outermost level of segments-- the ENDS has not been preceded by a matching SEGMENT directive. You need to look over your SEGMENT and ENDS directives, to get them to match up properly. ~42 Bad IF Operand~ This is reported when an IF is not followed by one of the flag-mnemonics (e.g., E, Z, NC, AE, etc.) that follow "J" in a conditional jump instruction. Most likely the line is a conditional assembly line intended for another assembler. In A86, conditional assembly lines begin with a hash sign #. So you change IF, ELSE, ENDIF to #IF, #ELSE, #ENDIF. You may also need to change the condition following IF: IF FOO EQU 0 becomes #IF !FOO; IFDEF FOO becomes simply #IF FOO. IF (expression) must be replaced by the two lines C1 EQU (expression) followed by #IF C1 . See Chapter 11 for the details of A86's syntax for conditional assembly. See Chapter 5 for the way A86 uses IF when it doesn't have a hash sign #. ~43 Parenthesis/Bracket Mismatch~ This is reported when there is a lack of balance of parentheses ( ) or brackets [ ] in an operand expression-- there are too many left-sides, too many right-sides, or the brackets are interleaved illegally: ( [ ) ]. Most likely you have left out an opening or closing parenthesis/bracket in a complicated expression; or a spurious extra ( ) [ or ] has crept into your code. ~44 Bad Forward Reference Combination~ This is reported when you try to use forward references in expressions that are too complicated for A86 to handle. You can add or subtract constants from forward-referenced symbols; but you can't subtract a forward-referenced symbol from anything, and you can't add two forward references together. You can typically get around restrictions in forward reference expressions by moving the expression down to an EQU directive after the point that the symbols are defined, and making a forward reference to the EQUated symbol that represents the evaluated expression. This error is also reported in some situations involving relocatable symbols in OBJ mode -- these symbols are forward references in the sense that they are resolved only at link time. ~45 Is It Byte Or Word?~ 14-9 This is reported when you have a memory operand of unspecified size, and A86 needs to know whether the operand is byte-sized or word-sized, in order to generate the correct instruction form. All you need to do is to append a B or a W to the operand, to specify the size you want. For example, if you've coded INC [BX], you need to decide between INC B[BX] and INC W[BX]. If you've coded ADD FOO,4 where FOO is a forward reference, you need to specify ADD FOO B,4 or ADD FOO W,4 . ~46 Bad #-Construct~ This is reported if, within a macro definition, a # is seen that is not followed by one of the allowed macro parameter constructs described in Chapter 11. Even in quoted strings, the hash sign # must be literalized via ## if it is to be taken as-is. If you mistakenly provide a macro-loop variable (#W, #X, #Y, or #Z) outside of any loop defining that variable, this error is detected when the macro is expanded, even though the error is in the macro definition. The error is also reported if # occurs at the beginning of a line, and is not followed by IF, ELSEIF, ELSE, or ENDIF; or if a conditional assembly parameter is a built-in mnemonic e.g. #IF MOV . See Chapter 11 for the correct usage of the hash sign in both macros and conditional assembly. ~47 #ENDIF Required~ This is reported if you have an #IF without a corresponding #ENDIF before the end of the file (or the end of the macro expansion if the #IF was assembled during a macro expansion). When this message appears at the end of a file, you need to search backwards for #IFs, to find the unclosed block. ~48 #EM Required To End Macro~ This is reported if you have a MACRO without an end. In A86, the end of a macro is given by #EM. Most likely your file was written for another assembler, and you need to convert macro definitions. You need to change all ENDM directives to #EM. You also need to eliminate the named parameters from the MACRO line, and replace occurrences of the named parameters with #1, #2, #3, etc. The & concatenation operator can be dropped. See Chapter 11 for a full description of A86's macro syntax. ~49 End Delimiter to COMMENT Required~ This is reported when the portion of code skipped in a COMMENT directive has run to the end of the file, without the closing delimiter being found. You need to search backwards from the end of the file to find the COMMENT directive, figure out where you intend the directive to end, and duplicate the delimiter (the first non-blank following COMMENT) at that end- point. See Chapter 4 for a full description of the COMMENT directive. 14-10 ~50 Reg,Mem Required~ This is reported when you have an improper combination of operands for a MOV, XCHG, or general arithmetic instruction such as ADD, SUB, CMP, XOR, etc. Most often you have attempted to provide two memory operands: MOV VAR1,VAR2 or ADD VAR1,VAR2. One of the operands must be a register. You can effect the memory-to-memory operation by using a register in a two-instruction sequence; for example, MOV AX,VAR2 followed by ADD VAR1,AX . For convenience, A86 lets you code the sequence with the single line ADD VAR1,AX,VAR2. If you don't wish to clobber the contents of any registers, and the operands are word-sized, you may PUSH the source operand and then POP to the destination operand: PUSH VAR2 followed by POP VAR1. ~51 Segment Override Not Allowed Here~ For compatibility with other assemblers, A86 allows segment override operators CS:, DS:, ES:, or SS: within expressions in instruction operands. The override informs the assembler that the named segment register is to be used for the memory reference, so that the assembler might generate a segment override opcode byte. This error is reported when a segment override operator occurs out of context: in A86's special three-operand form for MOV or arithmetic instructions; within a DATA segment or STRUC, or in an EQU directive. You might encounter the last case if you're porting a program written for another assembler. If so, you might have to provide explicit overrides wherever the EQUated symbol is used. It's possible, though, that the override is provided only to satisfy the other assembler's segment checking mechanism, and no overrides are generated at all. In that case, you can just eliminate the override operator. ~52 Byte Operand Required~ This is reported when an operand to one of the NEC-specific instructions STOBITS, LODBITS, ROL4, ROR4 is of the wrong type. STOBITS and LODBITS require the first operand to be a byte-sized register and the second operand to be either a byte-sized register or an immediate constant. ROL4 and ROR4 require the only operand to be a byte-sized register. ~53 Word Register Required~ This is reported when the first operand to any of the instructions LDS, LES, LEA, BOUND, IMUL, LAR, or LSL is not a word-sized general register (AX,BX,CX,DX,SI,DI,BP, or SP). ~54 Floating-Point Chip Required~ 14-11 This is reported when you attempt to assemble a program with floating point constants or floating point expressions, and you do not have a floating point chip (8087 or 287) in your computer system. A86 uses the 87 to assemble constants and do arithmetic. It's time for you to buy a chip and install it in that empty socket! ~55 Bad Floating-Point Operand~ This is reported when an operand to a floating point instruction is not of the correct type. See Chapter 7 for the correct forms for the instruction you're coding. Some possibilities for the error are: * a memory operand has unspecified size, or a size not compatible with the instruction. Integer instructions (FIxxx) require a W or D operand; floating arithmetic instructions require a D or Q operand. * you've tried to specify an 86 register instead of a memory operand. * you've tried A86's special FLD (constant) form in OBJ mode. Sorry, I support this only for COM mode (mainly for D86). * you've specified two register numbers (0 through 7), but neither is 0. * you've tried one of the disallowed forms FCOM i,0 or FCOMP i,0 ~56 Constant 0--7 Required~ This is reported if a constant number operand to an 87 instruction, which is supposed to represent an 87 stack number (0 through 7), does not have the right value; i.e., it's not an integer, or it's not in the range 0 through 7. ~57 Memory Operand Required~ This is reported when an operand to a floating-point or a 286 protected-mode instruction must be a memory operand, and the operand you've provided isn't one. See Chapters 7 (for floating) or 6 (for protected) for the correct syntax of the instruction you're coding. ~58 Segment Or Struc Name Not Allowed~ This error occurs most often when you are attempting to assemble as a COM program a file intended to be an EXE program. The COM format does not allow you to refer to the value of a named segment. We should either use the +O option to produce an OBJ file, or simply eliminate the statements intended to set the segment registers-- COM programs are started with all segment registers already pointing to the same value. 14-12 This error is also reported when you provide the name of a structure, or the name of an INT equate, in a place where a register or memory operand is expected. ~59 Word Operand Required~ This is reported when something other than a word-sized operand is provided for one of the 286 instructions ARPL, SLDT, LLDT, STR, LTR, VERR, VERW, SMSW, or LMSW. ~97 Object Overflow~ This is reported when the assembler runs out of room in its output object-code segment (which also holds records used to resolve forward references). This will happen only if your object output nears the object capacity, which is 64K if a full amount of memory (about 200K) is available to the assembler. If you have a limited amount of memory, you should increase the memory available to A86, by buying another board, or by having fewer memory-resident programs installed when you run A86. If you are assembling OBJ files, you can break the program into smaller assembled modules. It's conceivable that this error could result in a D86 session, when you are using patch-memory mode to type in an extremely complicated program. In that case, you should type the program into a text file instead, and use A86 to assemble the text file. ~98 Undefined Symbol Not Allowed~ This error should occur only during a D86 debugging session, when you type an immediate-execution assembly language line containing a symbol not in the table (typically a mistyping on your part). D86 allows you to add symbols to the table only when you are in patch-memory mode (reached by pressing the F7 key). ~99 Symbol Table Overflow~ This is reported when the symbol table runs out of space. It's unlikely that you'll ever run into this error, since A86's capacity is thousands of symbols. If you do, you'll need to reduce the number of symbols in your program. One way to do so is to replace all place-marker symbols with local labels in a limited range (like L0--L9). See Chapter 5 for a description of A86's local label facility.